{
 "metadata": {
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3",
   "language": "python"
  },
  "language_info": {
   "name": "python",
   "version": "3.10.12",
   "mimetype": "text/x-python",
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "pygments_lexer": "ipython3",
   "nbconvert_exporter": "python",
   "file_extension": ".py"
  },
  "kaggle": {
   "accelerator": "gpu",
   "dataSources": [],
   "dockerImageVersionId": 30616,
   "isInternetEnabled": true,
   "language": "python",
   "sourceType": "notebook",
   "isGpuEnabled": true
  }
 },
 "nbformat_minor": 4,
 "nbformat": 4,
 "cells": [
  {
   "cell_type": "code",
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n",
    "\n",
    "seed = 42\n",
    "torch.manual_seed(seed)\n",
    "torch.cuda.manual_seed_all(seed)\n"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:41.040886Z",
     "iopub.execute_input": "2023-12-08T03:56:41.041914Z",
     "iopub.status.idle": "2023-12-08T03:56:41.055773Z",
     "shell.execute_reply.started": "2023-12-08T03:56:41.041868Z",
     "shell.execute_reply": "2023-12-08T03:56:41.054673Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2025-02-04T06:55:36.266885Z",
     "start_time": "2025-02-04T06:55:30.359319Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.1\n",
      "torch 2.5.1+cpu\n",
      "cpu\n"
     ]
    }
   ],
   "execution_count": 1
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 准备数据"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "from tensorflow import keras\n",
    "#用karas有的数据集imdb，电影分类,分电影是积极的，还是消极的\n",
    "imdb = keras.datasets.imdb\n",
    "#载入数据使用下面两个参数\n",
    "vocab_size = 10000  #词典大小，仅保留训练数据中前10000个最经常出现的单词，低频单词被舍弃\n",
    "index_from = 3  #0,1,2,3空出来做别的事\n",
    "#前一万个词出现词频最高的会保留下来进行处理，后面的作为特殊字符处理，\n",
    "# 小于3的id都是特殊字符，下面代码有写\n",
    "# 需要注意的一点是取出来的词表还是从1开始的，需要做处理\n",
    "(train_data, train_labels), (test_data, test_labels) = imdb.load_data(\n",
    "    num_words = vocab_size, index_from = index_from)"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:41.057859Z",
     "iopub.execute_input": "2023-12-08T03:56:41.058565Z",
     "iopub.status.idle": "2023-12-08T03:56:46.434050Z",
     "shell.execute_reply.started": "2023-12-08T03:56:41.058535Z",
     "shell.execute_reply": "2023-12-08T03:56:46.433226Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2025-02-04T06:55:45.587575Z",
     "start_time": "2025-02-04T06:55:36.267873Z"
    }
   },
   "outputs": [],
   "execution_count": 2
  },
  {
   "cell_type": "code",
   "source": [
    "print(\"train\", train_data.shape, train_labels.shape)\n",
    "print(\"test\", test_data.shape, test_labels.shape)"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:46.437383Z",
     "iopub.execute_input": "2023-12-08T03:56:46.437705Z",
     "iopub.status.idle": "2023-12-08T03:56:46.443644Z",
     "shell.execute_reply.started": "2023-12-08T03:56:46.437678Z",
     "shell.execute_reply": "2023-12-08T03:56:46.442614Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2025-02-04T06:55:45.593748Z",
     "start_time": "2025-02-04T06:55:45.588570Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train (25000,) (25000,)\n",
      "test (25000,) (25000,)\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "cell_type": "code",
   "source": [
    "#载入词表，看下词表长度，词表就像英语字典\n",
    "word_index = imdb.get_word_index()\n",
    "print(len(word_index))\n",
    "print(type(word_index))\n",
    "#词表虽然有8万多，但是我们只载入了最高频的1万词！！！！"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:46.444961Z",
     "iopub.execute_input": "2023-12-08T03:56:46.445332Z",
     "iopub.status.idle": "2023-12-08T03:56:46.510542Z",
     "shell.execute_reply.started": "2023-12-08T03:56:46.445297Z",
     "shell.execute_reply": "2023-12-08T03:56:46.509651Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2025-02-04T06:55:45.666135Z",
     "start_time": "2025-02-04T06:55:45.594736Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "88584\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 构造 word2idx 和 idx2word"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "word2idx = {word: idx + 3 for word, idx in word_index.items()}\n",
    "word2idx.update({\n",
    "    \"[PAD]\": 0,     # 填充 token\n",
    "    \"[BOS]\": 1,     # begin of sentence\n",
    "    \"[UNK]\": 2,     # 未知 token\n",
    "    \"[EOS]\": 3,     # end of sentence\n",
    "})\n",
    "\n",
    "idx2word = {idx: word for word, idx in word2idx.items()}"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:46.513002Z",
     "iopub.execute_input": "2023-12-08T03:56:46.513314Z",
     "iopub.status.idle": "2023-12-08T03:56:46.555553Z",
     "shell.execute_reply.started": "2023-12-08T03:56:46.513267Z",
     "shell.execute_reply": "2023-12-08T03:56:46.554594Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2025-02-04T06:55:45.716059Z",
     "start_time": "2025-02-04T06:55:45.668263Z"
    }
   },
   "outputs": [],
   "execution_count": 5
  },
  {
   "cell_type": "code",
   "source": [
    "# 选择 max_length\n",
    "length_collect = {}\n",
    "for text in train_data:\n",
    "    length = len(text)\n",
    "    length_collect[length] = length_collect.get(length, 0) + 1\n",
    "    \n",
    "MAX_LENGTH = 500\n",
    "plt.bar(length_collect.keys(), length_collect.values())\n",
    "plt.axvline(MAX_LENGTH, label=\"max length\", c=\"gray\", ls=\":\")\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:46.556688Z",
     "iopub.execute_input": "2023-12-08T03:56:46.557006Z",
     "iopub.status.idle": "2023-12-08T03:56:48.567816Z",
     "shell.execute_reply.started": "2023-12-08T03:56:46.556979Z",
     "shell.execute_reply": "2023-12-08T03:56:48.566872Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2025-02-04T06:55:46.718809Z",
     "start_time": "2025-02-04T06:55:45.717887Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGdCAYAAAA44ojeAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAANVdJREFUeJzt3Ql0FFW++PEfawDZ1yRj2BVQdsSAIMIDDaAoiwqyDNuAIKDAiAhPZJn3XhQZxIcI4wyLCwjqY3HwCYd90YCAIIuIBJBlZBMkbBK2+p/fPa/rnw6pLNBdXZ18P+fc07e7Kp2boun61V1+lcuyLEsAAAA8JHeoGwAAAJAaAQoAAPAcAhQAAOA5BCgAAMBzCFAAAIDnEKAAAADPIUABAACeQ4ACAAA8J6+EoZs3b8ovv/wiRYoUkVy5coW6OQAAIBM0N+yFCxckOjpacufOnf0CFA1OYmJiQt0MAABwG44ePSp333139gtQtOfE9wcWLVo01M0BAACZcP78edPB4DuPZ7sAxTeso8EJAUr4uHHjhmzatMnUGzVqJHny5Al1kwAAIZCZ6RlhGaAgfAOUlStXmnrDhg0JUAAAjghQ4BqdEFWnTh27DgCAEwIUuCZv3rzSvn37UDcDAJDdApT4+HhZuHCh/Pjjj1KwYEF56KGH5M0335Rq1arZ+1y5ckX+/Oc/y/z58yU5OVni4uLkvffek3Llytn7HDlyRAYOHChr1qyRwoULS8+ePc176wkMAJA9lpNev37dDO0i58iTJ485lwciBUiWIoJ169bJoEGDzPwB/eCNHj1aHnvsMfnhhx/krrvuMvsMGzZMvvzyS/nss8+kWLFiMnjwYOnYsaN8/fXXZrt+WB9//HGJjIyUb775Ro4fPy5//OMfJV++fPJf//Vfd/wHAQBC6+rVq+a7/fLly6FuCkKgUKFCEhUVJfnz57+j98llaZh7m06fPi1ly5Y1gUuzZs0kKSlJypQpI/PmzZOnn37a7KO9LTVq1JCEhASzcuOrr76SJ554wuQy8fWqzJgxQ0aOHGneLzN/kC5T0uBHfx+reMLrS2vy5MmmPnz48Dv+8ALwZiLN/fv3mytpPR/o/3MSauYMlmWZ73k9l2tnxD333HPLfMOsnL/vaExFf4EqWbKkedy2bZtcu3ZNWrVqZe9TvXp1KV++vB2g6GOtWrX8hnx0GEiHfPbs2SP16tW75ffoUJGWlH8gwlPKf0cA2Y+eoDRI0VwXeiWNnKVgwYJmROTw4cPms1CgQIHbfq/bDlD0Azh06FBp0qSJ1KxZ07x24sQJEy0XL17cb18NRnSbb5+UwYlvu29bWnR+yvjx42+3qfAI/dDqkJ+vDiD7YqVezpU7QP/2t/0uOhdl9+7dZjJssI0aNcr01viKZpBF+NFu3lKlSplCly8AIOABil4FL1261KzCSZlLXye+apfOuXPn/PY/efKk2ebbR5+n3u7blpaIiAg7ayzZYwEA2V2uXLlk8eLF4gXjxo2TunXrejtA0QkwGpwsWrRIVq9eLZUqVfLb3qBBA9N1v2rVKvu1ffv2mWXFjRs3Ns/1cdeuXXLq1Cl7nxUrVpig47777rvzvwiepZOmvv32W1NYeggA3pPLQ4FR3qwO6+gKnSVLlpgb/fjmjOiMXJ0Yo499+/Y1KzR04qwGHUOGDDFBiU6QVbosWQORHj16yMSJE817vPbaa+a9tacE2ZcGJbqKS2k0Tqp7AEBAelCmT59u5oA0b97crHH2lQULFtj7vP3222YZcadOnczSYx220eRuPnpS0uEhfdTApXv37iYPyoQJE7LSFITpxCkNTrUwgQ6A1+i5TS+qdQFIiRIlzAKOv//973Lp0iXp3bu3uTCvWrWqfaHlu/DSC3MdUdALdU1c+s477/glL73//vulf//+9msHDhww7zVr1qxMt+3o0aPy7LPPmkUo2gHw1FNPyc8//2xv79Wrl8nUPWnSJHNe1rl+euGvK2t9NDeN5iHTdmp7tcOhYsWKMmXKFLNd66pDhw6mJ8X33Oejjz4yr2lnRJcuXeTChQsSVFYYSkpK0twt5hEA4B2///679cMPP5jH1JKTk025efOm/dr169fNa9euXQvovrfjkUcesYoUKWL95S9/sX766SfzmCdPHqtNmzbW+++/b14bOHCgVapUKevSpUvmZ65evWq9/vrr1pYtW6yDBw9aH3/8sVWoUCFrwYIF9vtu377dyp8/v7V48WLzNzRq1Mjq0KFDum0REWvRokX276hRo4bVp08fa+fOneb4du3a1apWrZr5u1XPnj2tokWLWgMGDLD27t1r/fOf/zTt0Hb7tGrVyqpbt661adMma9u2bebvLViwoPX222+b7adOnTK/d/bs2dbx48fNczV27FircOHCVseOHa1du3ZZ69evtyIjI63Ro0dn+TOQlfM3AQoAIGDSOzmNGzfOlIsXL9qvrVu3zry2ZMkSv33/8z//07z+22+/2a8lJCSY1/7nf/7Hb9+JEyea10+ePHlHbdcTdtOmTe3nGkzcddddVo8ePezX9MSt5x9ti5NBgwZZnTp1uqWNpUuXtgYPHmxFRUVZv/76a6YDlI8++sgEIykDMA1MNLhYvny5HaBUqFDBtNnnmWeesTp37mzqGrToe2og5bN//37zmi9ASf17fTRA0WDn/Pnz9msjRoywYmNjgxqgcPMbAAD+T+3ate26TkXQoRJNLpo6b1fKhR7Tpk0zwzW6IOT33383q1lTr3rRe9Tp5NN3333XDBHp+2bW999/L4mJiWZYKCUdPtLhIh8dSko5t0+HenRRim/Bit4jp379+vZ2Ha7SoazM0KGdlL9f3zvlMQgGAhS4RsdCp06dauo6zkuyNiBn0ZxWKuX/fU32qYsoUs9Le/nll2/ZV+8DpyfY1Pu+9NJLt+x7u1K/h87FSPmaL4eTJitVmgtM2/rXv/7VzKvUk/hbb70lmzdv9nsfPZn/9NNPJoDQWwG0bt060226ePGiWSU7d+7cW7bp7QTSa7uvnXcqmO/thAAFrtHeQ9+kqju4BRSAMJXW/bf0hJ3Wir473dcteiPchx56SF544QX7tZS9Gj59+vQxPTE6obZfv37mljB6n7rMqF+/vlmMove+u908YDp5V2/yu337dhPsKO2V+e23324JRLySBoKlFHCNdi8+//zzpmgdAMKd3hBv69atsnz5ctNDMmbMGNmyZYvfPjoEpPeh++CDD6Rbt25mtY0+6lBQZnTr1k1Kly5tVu5s2LBBDh06JGvXrpUXX3xRjh07lqn30PviaVCkq4k0F5UGKlrXFT0pM3vrUI7mMtMUIKmDF7cRoMA12i2ry861sMwYQHagF1wdO3aUzp07S2xsrJw5c8avN+XHH3+UESNGyHvvvWduoKi0/uuvv5pgJjMKFSok69evNzfe1d+lPS/aE6NzULLSo/Lhhx+aOTSaAkSXEmtPjg5Jpbyhnw5VafJUbWtaN+91U67/m7UbVrJyu2YAgHv0pKlX+Jpn407uZIvg094XDURWrlwpLVu2dOUzkJXzN/3scI2Oa/pmlOtYLJlkAcA9q1evNhNu9ftXk7a98sorZkhHe1S8iAAFrgYoepsEpdlkCVAAwN2VlKNHj5aDBw+aoR2d3Ksrg7y6opIABa7ReSc6ocxXBwC4Jy4uzpRwQYAC1+jKna5du4a6GQCAMMBlLAAA8BwCFABAwIXhAlF47N+eIR64OkFrxowZpj5gwADPTswCcPt8/68vX75skoAh57l8+bJ5vNPveAIUuBpVnz171q4DyH50dV7x4sXtG8lpkrGUmUqRfVmWZYIT/bfXz8CdrtQkQIGrk2R79+5t1wFkT5otWgX7brfwJg1OfJ+BO8FZAq7RpcWaqhlA9qY9JlFRUebmdjq0i5wjX758ActxRYACAAgKp7sPA5lBgALX3Lx5U/bu3WvqerMrkrUBAJxwhoBrrl+/Lp9//rkpWgcAwAk9KHB1XLpChQp2HQAAJwQocHXyVK9evULdDABAGGCIBwAAeA4BCgAA8ByGeOAazYcwc+ZMU+/bty+p7gEAjghQ4Goa5JMnT9p1AACcEKDANZrevnv37nYdAAAnnCXgGk3MVqVKlVA3AwAQBpgkCwAAPIceFLia6j4xMdHUq1atSqp7AIAjzhBwjaa3/+STT0wh1T0AID30oMA1mt4+OjrargMA4IQABa7RvCf9+vULdTMAAGGAIR4AABD+Acr69eulXbt2pqteu+kXL17st11fS6u89dZb9j4VK1a8Zfsbb7wRmL8IAADkvCGeS5cuSZ06daRPnz7SsWPHW7YfP37c7/lXX31l0pp36tTJ7/UJEyb4dfcXKVIkq01BGKa6/+ijj0y9R48epLoHAAQuQGnTpo0pTiIjI/2eL1myRFq0aCGVK1f2e10DktT7InvT9PZHjx616wAAhGQOit535csvvzQ9KKnpkE6pUqWkXr16ZvgnvWWnycnJcv78eb+C8KPp7Tt37mwKqe4BAOkJ6lnigw8+MD0lqYeCXnzxRalfv76ULFlSvvnmGxk1apQZGpo8eXKa7xMfHy/jx48PZlPhAk3MVr169VA3AwAQBnJZd9DXrpNbFy1aJO3bt09zu56MHn30UZk6dWq67zNr1ix5/vnn5eLFixIREZFmD4oWH+1BiYmJkaSkJClatOjtNh8AALhIz9/FihXL1Pk7aD0oGzZskH379smCBQsy3Dc2NtYM8fz8889SrVq1W7Zr0JJW4ILwS3V/5MgRUy9fvjyp7gEAjoJ2hpg5c6Y0aNDArPjJyI4dO8zJqmzZssFqDjxAg1Ad9tNCqnsAQEB7UHQYxnfDN3Xo0CETYOh8Er0q9nXhfPbZZ/LXv/71lp9PSEiQzZs3m5U9Oj9Fnw8bNky6d+8uJUqUyGpzEEZ0SLBMmTJ2HQCAgM1BWbt2rQkuUuvZs6fMmTPH1N9//30ZOnSomfiqY00pfffdd/LCCy/Ijz/+aOaVVKpUyeTEGD58eKaHcbIyhgUAALwhK+fvO5okGyoEKAAAhJ+snL+ZpQgAADyHbFlwNdX9/PnzTb1Lly6kugcAOCJAgWt0NPHgwYN2HQAAJwQocI2mt+/QoYNdBwDACWcJuEZz3dSuXTvUzQAAhAEmyQIAAM+hBwWuprrX3DgqKiqKVPcAAEecIeAaTW//j3/8wxRS3QMA0kMPClyj6e19mYVJdQ8ASA8BClyjeU/0FggAAGSEIR4AAOA5BCgAAMBzGOKBa3Ri7Oeff27qTz/9NMnaAACOOEPA1WXG+/bts+sAADghQIFr8uTJI0888YRdBwDACXNQXFLx1S8lp9OgpEGDBqYQoAAA0kOAAgAAPIchHrjGsiw5ffq0qZcpU4ZkbQAAR/SgwDXXrl2T6dOnm6J1AACc0IMCVxUqVCjUTQAAhAECFLgmf/78MmLEiFA3AwAQBhjiAQAAnkOAAgAAPIchHria6v6LL74w9SeffJJU9wAAR/SgwDWa3n7Xrl2mkOoeAJAeLmHhGs0eGxcXZ9cBAHBCgALXaFDSqFGjUDcDABAGGOIBAACeQw8KXE11n5SUZOrFihUj1T0AwBE9KHCNprd/5513TCHVPQAgPfSgwFX58uULdRMAAGGAAAWuprofPXp0qJsBAAgDDPEAAADPIUABAADhH6CsX79e2rVrJ9HR0WYVxuLFi/229+rVy7yesrRu3dpvn7Nnz0q3bt2kaNGiUrx4cenbt69cvHjxzv8ahEWqey1aBwAgYAHKpUuXpE6dOjJt2jTHfTQgOX78uF0++eQTv+0anOzZs0dWrFghS5cuNUFP//79s9oUhBlNb799+3ZTSHUPAAjoJNk2bdqYkp6IiAiJjIxMc9vevXtl2bJlsmXLFnnggQfMa1OnTpW2bdvKpEmTTM8Msm8m2RYtWth1AABcnYOydu1aKVu2rFSrVk0GDhwoZ86csbclJCSYYR1fcKJatWoluXPnls2bN6f5fsnJyXL+/Hm/gvCjQUmzZs1MIUABALgaoOjwzocffiirVq2SN998U9atW2d6XG7cuGG2nzhxwgQvKeXNm1dKlixptqUlPj7eZB71lZiYmEA3GwAAZOc8KF26dLHrtWrVktq1a0uVKlVMr0rLli1v6z1HjRolw4cPt59rDwpBSnimur98+bKpFypUiFT3AIDQLTOuXLmylC5dWhITE81znZty6tQpv310RYeu7HGat6JzWnTFT8qC8KPp7XWekRZS3QMAQhqgHDt2zMxBiYqKMs8bN24s586dk23bttn7rF692qzqiI2Nleyu4qtfhroJAABkvyEezVfi6w1Rhw4dkh07dpg5JFrGjx8vnTp1Mr0hBw4ckFdeeUWqVq0qcXFxZv8aNWqYeSr9+vWTGTNmmCvpwYMHm6EhVvBk/1T3Y8eODXUzAADZsQdl69atUq9ePVOUzg3R+uuvv25WZuzcuVOefPJJuffee00CtgYNGsiGDRvMMI3P3LlzpXr16mZOii4vbtq0qbz//vuB/csAAEDO6UFp3ry5mezoZPny5Rm+h/a0zJs3L6u/GgAA5BDczRiu0cnQK1eutHPf6PJyAADSws0C4RqdCK3J+LSQ6h4AkB4uYeEanaOk8418dQAAnBCgwDUalNxusj4AQM7CEA8AAPAcelDgGl395csgmy9fPlLdAwAc0YMC12hwojd+1EKqewBAeghQgozU9gAAZB1DPHCNDuvonal9dQAAnBCgwDU650TvxwMAQEYY4gEAAJ5DgBIiOXFuyo0bN2TVqlWmaB0AACcEKHCNBiUbN240hQAFAJAe5qDANblz55bY2Fi7DgCAEwIUuEbvXty6detQNwMAEAa4jAUAAJ5DgAIAADyHIR645urVqybNvdKEbeREAQA4oQcFAAB4Dj0ocI2mt3/55ZftOgAATghQ4Gqq+7vuuivUzQAAhAGGeAAAgOfQgwLXaPbYr7/+2tSbNGkiefLkCXWTAAAeRYACVwOUNWvWmHqjRo0IUAAAjghQ4BpNb1+vXj27DgCAEwIUuJrq/sknnwx1MwAAYYDLWAAA4DkEKAAAwHMY4oGrqe4nTZpk6pqwjVT3AAAnBChw1bVr10LdBABAGCBAgWs0vf1LL71k1wEAcEKAAldT3RcvXjzUzQAAhAEmyQIAAM+hBwWuZpLdsmWLqTds2JBMsgCAwPWgrF+/Xtq1ayfR0dGmy37x4sV+EyBHjhwptWrVMnet1X3++Mc/yi+//OL3HhUrVjQ/m7K88cYbWW0KwjBAWb58uSlaBwAgYAHKpUuXpE6dOjJt2rRbtl2+fFm+++47GTNmjHlcuHCh7Nu3L83soRMmTJDjx4/bZciQIVltCsKMprfX4FULqe4BAAEd4mnTpo0paSlWrJisWLHC77V3331XHnzwQTly5IiUL1/efr1IkSISGRmZ1V+PME9137Fjx1A3AwAQBoJ+GZuUlJTm6g0d0ilVqpS5edxbb70l169fd3yP5ORkOX/+vF8BAADZV1AnyV65csXMSXnuueekaNGi9usvvvii1K9fX0qWLCnffPONjBo1ygzzTJ48Oc33iY+Pl/HjxwezqQAAICcEKDph9tlnnxXLsmT69Ol+24YPH27Xa9eubVKeP//88yYQiYiIuOW9NIBJ+TPagxITExOspiOIqe7feecdU9eEbaS6BwC4GqD4gpPDhw/L6tWr/XpP0hIbG2uGeH7++WepVq3aLds1aEkrcEH40YnUAAC4HqD4gpP9+/fLmjVrzDyTjOzYscOs6ihbtmygmwMP0fT2AwcOtOsAAAQsQLl48aIkJibazw8dOmQCDJ1PEhUVJU8//bRZYrx06VKT6+LEiRNmP92uXfoJCQmyefNmadGihVnJo8+HDRsm3bt3lxIlSmS1OQgjOlmaIBQAEJQAZevWrSa48PHNDenZs6eMGzdOvvjiC/O8bt26fj+nvSnNmzc3QzXz5883++rqnEqVKpkAJeUcEwAAkLNlOUDRIEMnvjpJb5vS1TubNm3K6q9FNqA9atrb5gtgSXUPAHDCvXjgaoCiQ39Ks8kSoAAAnBCgwDU6Edq3SotU9wCA9BCgwNVU9126dAl1MwAAYYDLWAAA4DkEKAAAwHMY4oFrNInftGnTTH3QoEEkawMAOCJAgWt0Cbre3dpXBwDACQEKXJ0k+6c//cmuAwDghLMEXKNLi//whz+EuhkAgDDAJFkAAOA59KDANTdv3pTdu3ebes2aNUnWBgBwRIAC11y/fl0WLVpk6tWrVzd3twYAIC0EKHBNrly5pHLlynYdAAAnBChwjeY96dGjR6ibAQAIA0wCAAAAnkOAAgAAPIchHria6v7vf/+7qffr149U9wAARwQocI2mtz99+rRdBwDACQEKXKPp7Xv27GnXAQBwwlkCrtHEbBUrVgx1MwAAYYBJsgAAwHPoQYGrqe5/+uknU7/33ntJdQ8AcMQZAq6mul+wYIEpWgcAwAk9KHCNprePiYmx6wAAOCFAgWs070mfPn1C3QwAQBhgiAcAAHgOAQoAAPAchnjgaqr7OXPmmHqvXr1IdQ8AcESAAtdoevtffvnFrgMA4IQABa7R9PbPPfecXQcAwAlnCbhGE7NpgjYAADLCJFkAAOA59KDA1VT3hw4dMvVKlSqR6h4A4IgzBFyj6e0//vhjU0h1DwAIaICyfv16adeunURHR5t05YsXL/bbrqszXn/9dYmKipKCBQtKq1atZP/+/X77nD17Vrp16yZFixaV4sWLS9++feXixYtZbQrCjH5eypUrZwqp7gEAAQ1QLl26JHXq1JFp06aluX3ixIny3//93zJjxgzZvHmz3HXXXRIXFydXrlyx99HgZM+ePbJixQpZunSpCXr69++f1aYgzGjekwEDBphCDhQAQEDnoLRp08aUtGjvyZQpU+S1116Tp556yrz24Ycfmitm7Wnp0qWL7N27V5YtWyZbtmyRBx54wOwzdepUadu2rUyaNMn0zAAAgJwtoHNQdALkiRMnzLCOT7FixSQ2NlYSEhLMc33UYR1fcKJ0f50wqT0uaUlOTpbz58/7FQAAkH0FNEDR4ERpj0lK+ty3TR/Lli3rt12TdpUsWdLeJ7X4+HgT6PhKTExMIJsNl1Pda9E6AABhvYpn1KhRkpSUZJejR4+Gukm4DToEePjwYVNIdQ8AcC0PSmRkpHk8efKkWcXjo8/r1q1r73Pq1Cm/n9Mlp7qyx/fzqUVERJiC8KY9ZU8//bRdBwDAlR4UTb6lQcaqVavs13S+iM4tady4sXmuj+fOnZNt27bZ+6xevdok8dK5Ksi+dJ7R/fffbwpJ2gAA6cnyZazmK0lMTPSbGLtjxw4zh6R8+fIydOhQ+Y//+A+55557TMAyZswYszKnffv2Zv8aNWpI69atpV+/fmYpss5FGDx4sFnhwwoeAABwWwHK1q1bpUWLFvbz4cOHm8eePXuayY+vvPKKyZWieU20p6Rp06ZmWXGBAgXsn5k7d64JSlq2bGmupDt16mRypyB7016yY8eOmfrdd99NLwoAIHABSvPmzdOd4KgZQidMmGCKE+1tmTdvXlZ/NcKczjWaPXu2PfE5f/78oW4SAMCjmKkI12jwqsGprw4AgBMCFLhG09sPGTIk1M0AAIQBJgF4RMVXvwx1EwAA8AwCFAAA4DkM8cDVSbKffvqpqT/77LMkawMAOKIHxWNDO9l5qEeXGe/fv98UrQMA4IRLWLgmT5488tRTT9l1AACcEKDANRqU+O7JBABAehjiAQAAnkMPClyj8058d7IuW7Ysqe4BAI44Q8DVVTx/+9vfTNE6AABO6EGBazS9fZEiRew6AABOCFDgaqp7392vAQBID0M8AADAcwhQAACA5zDEA9foxNhFixaZeocOHUh1DwBwRA8KXF1m/MMPP5hCqnsAQHq4hIWrmWTbtGlj1wEAcEKAAtdoUPLggw+GuhkAgDDAEA8AAPAcelDgGsuy5OzZs6ZesmRJkrUBABzRgwLXXLt2Td59911TtA4AgBN6UOCqiIiIUDcBABAGCFDgmvz588urr74a6mYAAMIAQzwAAMBzCFAAAIDnMMQDV1PdL1261NSfeOIJUt0DABzRgwLXaHr777//3hRS3QMA0sMlLFzNJNuqVSu7DgCAEwIUuEaDkiZNmoS6GQCAMMAQDwAA8Bx6UOBqqvsLFy6YepEiRUh1DwBwRA+KR1V89UvJbjS9/dtvv20Kqe4BAK4GKBUrVjRXxqnLoEGDzPbmzZvfsm3AgAGBbgY8Knfu3KYAAODqEM+WLVvkxo0b9vPdu3fLo48+Ks8884z9Wr9+/WTChAn280KFCgW6GfBoqvsxY8aEuhkAgJwYoJQpU8bv+RtvvCFVqlSRRx55xC8giYyMDPSvBgAA2URQ+9qvXr0qH3/8sfTp08dvQuTcuXOldOnSUrNmTRk1apRcvnw5mM0AAABhJqireBYvXiznzp2TXr162a917dpVKlSoINHR0bJz504ZOXKk7Nu3TxYuXOj4PsnJyab4nD9/PpjNRhBT3S9fvtzU4+LiSHUPAHAU1DPEzJkzpU2bNiYY8enfv79dr1WrlkRFRUnLli3lwIEDZigoLfHx8TJ+/PhgNhUu0PT2W7duNXWdlwQAgOtDPIcPH5aVK1fKn/70p3T3i42NNY+JiYmO++gwUFJSkl2OHj0a8PbCnUyyOhdJC6nuAQAh6UGZPXu2lC1bVh5//PF099uxY4d51J4UJxEREaYgvGlQosvMAQAISYCiXfkaoPTs2dNvnoEO48ybN0/atm0rpUqVMnNQhg0bJs2aNZPatWsHoykAACAMBSVA0aGdI0eOmNU7qfNg6LYpU6bIpUuXJCYmRjp16iSvvfZaMJoBD6a690121h4xUt0DAFwNUB577DFzMkpNA5J169YF41ciDGh6+zfffNOeV6QBKwAAaSHnOAAA8BwSUcA1+fLls4fzuB8PACA9BChwjc45YXkxACAzuIwNkoqvfumJ9wAAIBzRgwLX6F2uV61aZeqaPZjeFACAE3pQ4GqAkpCQYIrWAQBwQoASBrLLUI/2mDRu3NgUek8AAOlhiAeu0aBEc+QAAJARelAAAIDn0IMC12h2Yb1Pky8PCqnuAQBOCFDgaqr7+Ph4UyfVPQAgPQzxAAAAz6EHxeOyywoeX6r7kSNH2nUAAJwQoMA1OuekQIECoW4GACAMMMQDAAA8hx4UuEazx27YsMHUH374YZK1AQAcEaDA1QBl3bp1pv7QQw8RoAAAHBGgwDWa++SBBx6w6wAAOCFAgWvy5s0rjz/+eKibAQAIA1zGhqnstPwYAIDUCFAAAIDnEKCEkXDvNbl69ar85S9/MUXrAAA4IUAJM+EepOjNAn03DAQAwAmTZOEaTW8/bNgwuw4AgBMCFLia6r5o0aKhbgYAIAwwxAMAADyHHhS4mkl206ZNpt6oUSMyyQIAHBGgwNUAZeXKlabesGFDAhQAgCMCFLhG09vXqVPHrgMA4IQABa6mum/fvn2omwEACANcxoahcM+FAgBARghQwgRBCQAgJ2GIB67R9PaTJ0829eHDh0v+/PlD3SQAgEfRg5JNelbCpYclOTnZFAAAXA1Qxo0bZzKGpizVq1e3t1+5ckUGDRokpUqVksKFC0unTp3k5MmTgW4GPEjT2w8ePNgUUt0DAFzvQbn//vvl+PHjdtm4caO9Te/F8s9//lM+++wzWbdunfzyyy/SsWPHYDQDHqPBqgamWrQOAICrc1B0OWlkZOQtryclJcnMmTNl3rx58m//9m/mtdmzZ0uNGjVMhlHNLgoAABCUHpT9+/dLdHS0VK5cWbp16yZHjhwxr2/btk2uXbsmrVq1svfV4Z/y5ctLQkKC4/vpnIXz58/7lVDz6pwPr7bLl0n222+/NUXrAAC4FqDExsbKnDlzZNmyZTJ9+nQ5dOiQPPzww3LhwgU5ceKEWblRvHhxv58pV66c2eYkPj5eihUrZpeYmJhANxsu0KDkq6++MoUABQDg6hBPmzZt7Hrt2rVNwFKhQgX59NNPpWDBgrf1nqNGjTLLUn20B4UgJfxoevv77rvPrgMAELI8KNpbcu+990piYqI8+uijJhfGuXPn/HpRdBVPWnNWfCIiIkzxCq8Mo3ilHVmZm/TMM8+EuhkAgDAQ9MvYixcvyoEDByQqKkoaNGhglpeuWrXK3r5v3z4zR6Vx48bBbgoAAMipPSgvv/yytGvXzgzr6BLisWPHSp48eeS5554z80f69u1rhmtKliwpRYsWlSFDhpjghBU8AAAgaAHKsWPHTDBy5swZKVOmjDRt2tQsIda6evvtt838A03Qpqtz4uLi5L333gt0M+BBuoJr6tSppq6BKcnaAACuBSjz589Pd3uBAgVk2rRppiBnsSzLrOby1QEAcMLNAuHqJNnnn3/ergMA4ISzBFyjQ3vprdYCAMCHZBQAAMBz6EGBazR77K5du0y9Vq1aZnUXAABpIUCBqwHKkiVLTF0zyhKgAACcEKDA1Tko99xzj10HAMAJAUo2Ty/vJbpyp2vXrqFuBgAgDHAZCwAAPIcA5Q7RowIAQOAxxANXU93PmDHD1AcMGECqewCAIwIUuEbT2589e9auAwDghAAlCEM+P7/xeKib4dlJsr1797brAAA44SwB1+jS4vLly4e6GQCAMMAk2WyOSbwAgHBEDwpcc/PmTdm7d6+p16hRg2RtAABHnCHgmuvXr8vnn39uitYBAHBCDwpckytXLqlQoYJdBwDACQEKXKN5T3r16hXqZgAAwgBDPAAAwHMIUHLIyh19jRU9AIBwwRBPNhAugYemup85c6ap9+3bl1T3AABHBChwjaa3P3nypF0HAMAJAUo27UnxYsp9TW/fvXt3uw4AgBPOEnCNJmarUqVKqJsBAAgDTJLNhnM9AAAId/SgwNVU94mJiaZetWpVUt0DABxxhsgBvSeZabsbf5+mt//kk09MIdU9ACA99KDANZrePjo62q4DAOCEAAWu0bwn/fr1C3UzAABhgCGeHCqch6wAANkfAQoAAPAcApQAyU49EsH6WzTV/axZs0zROgAATpiDAtdoevujR4/adQAAnBCgwDWa3r5z5852HQAA14Z44uPjpWHDhlKkSBEpW7astG/fXvbt2+e3T/Pmzc0y05RlwIABgW4KPEYTs1WvXt0UkrQBANIT8LPEunXrZNCgQbJp0yZZsWKFmWvw2GOPyaVLl/z20+Wmx48ft8vEiRMD3RQAABCmAt7PvmzZMr/nc+bMMT0p27Ztk2bNmtmvFypUSCIjIwP96+HxVPdHjhwx9fLly9OLAgBwFPQzRFJSknksWbKk3+tz586V0qVLS82aNWXUqFFy+fJlx/dITk6W8+fP+xXc3mqcUK420vT2H3zwgSmkugcApCdvsK+Yhw4dKk2aNDGBiE/Xrl2lQoUKJu35zp07ZeTIkWaeysKFCx3ntYwfPz6YTc1RQhWk6FyjMmXK2HUAAEISoOhclN27d8vGjRv9Xu/fv79dr1WrlkRFRUnLli3lwIEDUqVKlVveR3tYhg8fbj/XHpSYmJhgNh1BSnX/wgsvhLoZAICcHKAMHjxYli5dKuvXr5e777473X1jY2PNY2JiYpoBSkREhCkITk/Kz288HuqmAAAQ3ABFE3ANGTJEFi1aJGvXrpVKlSpl+DM7duwwj9qTAgAAkDcYwzrz5s2TJUuWmFwoJ06cMK8XK1ZMChYsaIZxdHvbtm2lVKlSZg7KsGHDzAqf2rVrB7o58BBdcj5//nxT79KlixnyAQDAlQBl+vTpdjK2lGbPni29evWS/Pnzy8qVK2XKlCkmN4rOJenUqZO89tprgW4KPEZ71w4ePGjXAQBwdYgnPRqQaDI3eHNOim8+Ssp6oGh6+w4dOth1AACccJaAazQxG8N4AIDMIJUn/PKihDKRGwAAPgQoyFBmg5aM9tPEff/6179M0ToAAE4IUOAaTW//j3/8wxRS3QMA0kOAgizz9ZRkdThI09vrcnMtpLoHAKSHSbJwjeY90XszAQCQEXpQAACA5xCgAAAAzyFAgWtLkHVirKa618IkWQBAepiDAtfo0uJ9+/bZdQAAnBCgwFGgk7blyZNHnnjiCbsOAIATAhS4RoOSBg0ahLoZAIAwwBwUAADgOfSgZAL3pwncna5Pnz5t6mXKlCFZGwDAET0ocM21a9dk+vTppmgdAAAnBChwteepUKFCpgAAkB6GeOCa/Pnzy4gRI0LdDABAGKAHBQAAeA4BCgAA8BwCFLi2yknT2y9cuNAUUt0DANJDgALXaHr7Xbt2mZJWqnuWcwMAfAhQ4Gom2bi4ONl8NYZU9wCAdBGgwDVV/n2ZNGrUSH64Uc4EKLfbY6I/R28LAGRvBCgAAMBzCFAQcKl7N/7/c0vOnTsnhXMlm7T3t/Net7svPS4AEF4IUOCavHJT3nnnHXmmwC5S3QMA0kWAAlfly5dPrlm5b7uHI63eGaefpdcEAMIXAQpcc13yyOjRo+XjK/VN2nsAAJwQoCDkUvZ0+HpEUveM3MmKnzvZDgAIDQKUdHDyCj8ZLUHOasDCZwAAQoO7GcM1ueWmfPHFF/JQvqOkugcApIseFLgmt1iyfft2qZb31zRT3Tvx9WKk17txO8uR0/v5O+05yczP3+7EYDd/NwCECgEKXHNTckmLFi1k27VoUt0DANJFgJIBrjQD56bklmbNmsnO68EPUDLqXclq74tTL86dtCsr+97J7w9U2wEgxwQo06ZNk4oVK0qBAgUkNjZWvv3221A2BwAA5PQAZcGCBTJ8+HAZO3asfPfdd1KnTh1zp9tTp06JF3C1GQyWXLp0SSLkWqZT3XtVMFb73E5PT1pLstP7WT7XAMJFyAKUyZMnS79+/aR3795y3333yYwZM6RQoUIya9YsCTW+xIOX6n7SpEnSteD3IUl1H4ycKBkFKhlNyL3dwCGtoMTptYzanN7vCKZg3ZU6EP+OoWxLMN8HCKfPXEiWGV+9elW2bdsmo0aNsl/LnTu3tGrVShISEm7ZPzk52RSfpKQk83j+/PmgtO9m8uVM7ae/X/cN1qOXBOpvupLrSprv5yVu/LumV/dxOi6ZOWaZ3Sc9vjYHS1p/c6DeN6vvGay/NVDvG+x/C8Ctz5zvPTPVi26FwL/+9S9tmfXNN9/4vT5ixAjrwQcfvGX/sWPHmv0pFAqFQqFI2JejR49mGCuERaI27WnR+So+mkPj7NmzUqpUKcmVK1fAorqYmBg5evSoFC1aNCDviVtxnN3DsXYPx9o9HOvwPtbac3LhwgWJjo7OcN+QBCilS5c2y0xPnjzp97o+j4yMvGX/iIgIU1IqXrx4UNqm/wh86IOP4+wejrV7ONbu4ViH77EuVqyYdyfJ6p1sGzRoIKtWrfLrFdHnjRs3DkWTAACAh4RsiEeHbHr27CkPPPCAPPjggzJlyhSzBFVX9QAAgJwtZAFK586d5fTp0/L666/LiRMnpG7durJs2TIpV65cSNqjQ0iakyX1UBICi+PsHo61ezjW7uFY55xjnUtnyobkNwMAADjgXjwAAMBzCFAAAIDnEKAAAADPIUABAACeQ4AiItOmTZOKFStKgQIFJDY2Vr799ttQNymsjBs3zmT0TVmqV69ub79y5YoMGjTIZP4tXLiwdOrU6ZYkfUeOHJHHH3/c3DCybNmyMmLECLl+/brkdOvXr5d27dqZrIt6XBcvXuy3Xee460q4qKgoKViwoLmf1f79+/320azL3bp1M4mWNMFh37595eLFi3777Ny5Ux5++GHzf0AzR06cOFFymoyOda9evW75nLdu3dpvH451xuLj46Vhw4ZSpEgR83+9ffv2sm/fPr99AvWdsXbtWqlfv75ZhVK1alWZM2eO5CTxmTjWzZs3v+VzPWDAAG8cayuHmz9/vpU/f35r1qxZ1p49e6x+/fpZxYsXt06ePBnqpoUNvVfS/fffbx0/ftwup0+ftrcPGDDAiomJsVatWmVt3brVatSokfXQQw/Z269fv27VrFnTatWqlbV9+3brf//3f63SpUtbo0aNsnI6PRb//u//bi1cuNDcv2LRokV+29944w2rWLFi1uLFi63vv//eevLJJ61KlSpZv//+u71P69atrTp16libNm2yNmzYYFWtWtV67rnn7O1JSUlWuXLlrG7dulm7d++2PvnkE6tgwYLW3/72NysnyehY9+zZ0xzLlJ/zs2fP+u3Dsc5YXFycNXv2bPP379ixw2rbtq1Vvnx56+LFiwH9zjh48KBVqFAha/jw4dYPP/xgTZ061cqTJ4+1bNkyK6eIy8SxfuSRR8x5L+XnWj+nXjjWOT5A0ZsTDho0yH5+48YNKzo62oqPjw9pu8ItQNEv5bScO3fOypcvn/XZZ5/Zr+3du9ecABISEsxz/cDnzp3bOnHihL3P9OnTraJFi1rJycku/AXhIfVJ8+bNm1ZkZKT11ltv+R3viIgIc+JT+mWhP7dlyxZ7n6+++srKlSuXuWmneu+996wSJUr4HeuRI0da1apVs3IqpwDlqaeecvwZjvXtOXXqlDlu69atC+h3xiuvvGIunFLq3LmzOWnnVKdSHWtfgPLSSy85/kwoj3WOHuK5evWqbNu2zXSL++TOnds8T0hICGnbwo0OK2jXeOXKlU0Xt3YJKj2+165d8zvGOvxTvnx5+xjrY61atfyS9MXFxZkbVe3ZsycEf014OHTokElymPLY6j0udJgy5bHVoQbN2Oyj++vnfPPmzfY+zZo1M7egSHn8tSv4t99+c/Vv8jrtxtYu7mrVqsnAgQPlzJkz9jaO9e1JSkoyjyVLlgzod4buk/I9fPvk5O/2pFTH2mfu3LnmHnk1a9Y0N+e9fPmyvS2Uxzos7mYcLL/++qvcuHHjluy1+vzHH38MWbvCjZ4QdbxRv7SPHz8u48ePN2Psu3fvNidQ/TJOfXNHPca6TeljWv8Gvm1Im+/YpHXsUh5bPaGmlDdvXvMFlXKfSpUq3fIevm0lSpQI6t8RLnS+SceOHc2xOnDggIwePVratGljvoT15qcc66zTe7ANHTpUmjRpYk6OKlDfGU776In1999/N3O2cvqxVl27dpUKFSqYC0ydHzVy5EgTMC9cuDDkxzpHBygIDP2S9qldu7YJWPQD/+mnn+a4LwFkX126dLHrekWpn/UqVaqYXpWWLVuGtG3hSifC6oXMxo0bQ92UHHus+/fv7/e51gn3+nnWIFw/36GUo4d4tEtLr3xSzw7X55GRkSFrV7jTK597771XEhMTzXHUobRz5845HmN9TOvfwLcNafMdm/Q+v/p46tQpv+06+15Xm3D874wOZ+p3iH7OFcc6awYPHixLly6VNWvWyN13322/HqjvDKd9dIVVTrtwGuxwrNOiF5gq5ec6VMc6Rwco2o3YoEEDWbVqlV83mD5v3LhxSNsWznRZpUbfGonr8c2XL5/fMdbuQ52j4jvG+rhr1y6/L/cVK1aYD/d9990Xkr8hHOhQgX4xpDy22qWq8x1SHlv9otdxfZ/Vq1ebz7nvi0j30SW2Ou6f8vjrkF1OG3LIimPHjpk5KPo5VxzrzNE5yHrCXLRokTk+qYe8AvWdofukfA/fPjnpu93K4FinZceOHeYx5ec6ZMfayuF0mbGuepgzZ46Zhd+/f3+zzDjljGWk789//rO1du1a69ChQ9bXX39tlqPpMjSdMe5bMqhL21avXm2WDDZu3NiU1MvYHnvsMbMUTpemlSlThmXGlmVduHDBLO3Tov9dJ0+ebOqHDx+2lxnr53XJkiXWzp07zSqTtJYZ16tXz9q8ebO1ceNG65577vFb+qqrJnTpa48ePcxyRP0/oUsGc9LS14yOtW57+eWXzSoS/ZyvXLnSql+/vjmWV65csd+DY52xgQMHmqXx+p2Rcmnr5cuX7X0C8Z3hW/o6YsQIswpo2rRpOW6Z8cAMjnViYqI1YcIEc4z1c63fI5UrV7aaNWvmiWOd4wMUpWu29T+D5kPRZceawwCZp8vJoqKizPH7wx/+YJ7rB99HT5YvvPCCWV6pH+IOHTqY/yQp/fzzz1abNm1MTggNbjTouXbtmpXTrVmzxpwsUxdd8upbajxmzBhz0tNAu2XLlta+ffv83uPMmTPmJFm4cGGzNLB3797mhJuS5lBp2rSpeQ/9N9TAJ6dJ71jrF7p+QesXsy6BrVChgskdkfpChmOdsbSOsRbN1xHo7wz9N61bt675btITb8rfkRNIBsf6yJEjJhgpWbKk+Txq3h4NMlLmQQnlsc71f38EAACAZ+ToOSgAAMCbCFAAAIDnEKAAAADPIUABAACeQ4ACAAA8hwAFAAB4DgEKAADwHAIUAADgOQQoAADAcwhQAACA5xCgAAAAzyFAAQAA4jX/D2EGIfFCCI1rAAAAAElFTkSuQmCC"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 6
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Tokenizer"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "class Tokenizer:\n",
    "    def __init__(self, word2idx, idx2word, max_length=500, pad_idx=0, bos_idx=1, eos_idx=3, unk_idx=2):\n",
    "        self.word2idx = word2idx\n",
    "        self.idx2word = idx2word\n",
    "        self.max_length = max_length\n",
    "        self.pad_idx = pad_idx\n",
    "        self.bos_idx = bos_idx\n",
    "        self.eos_idx = eos_idx\n",
    "        self.unk_idx = unk_idx\n",
    "    \n",
    "    def encode(self, text_list, padding_first=False):\n",
    "        \"\"\"如果padding_first == True，则padding加载前面，否则加载后面\"\"\"\n",
    "        max_length = min(self.max_length, 2 + max([len(text) for text in text_list]))\n",
    "        indices_list = []\n",
    "        for text in text_list:\n",
    "            indices = [self.bos_idx] + [self.word2idx.get(word, self.unk_idx) for word in text[:max_length-2]] + [self.eos_idx] #直接切片取前max_length-2个单词，然后加上bos和eos\n",
    "            if padding_first:\n",
    "                indices = [self.pad_idx] * (max_length - len(indices)) + indices\n",
    "            else:\n",
    "                indices = indices + [self.pad_idx] * (max_length - len(indices))\n",
    "            indices_list.append(indices)\n",
    "        return torch.tensor(indices_list)\n",
    "    \n",
    "    \n",
    "    def decode(self, indices_list, remove_bos=True, remove_eos=True, remove_pad=True, split=False):\n",
    "        text_list = []\n",
    "        for indices in indices_list:\n",
    "            text = []\n",
    "            for index in indices:\n",
    "                word = self.idx2word.get(index, \"[UNK]\")\n",
    "                if remove_bos and word == \"[BOS]\":\n",
    "                    continue\n",
    "                if remove_eos and word == \"[EOS]\":\n",
    "                    break\n",
    "                if remove_pad and word == \"[PAD]\":\n",
    "                    break\n",
    "                text.append(word)\n",
    "            text_list.append(\" \".join(text) if not split else text)\n",
    "        return text_list\n",
    "    \n",
    "\n",
    "tokenizer = Tokenizer(word2idx=word2idx, idx2word=idx2word)\n",
    "raw_text = [\"hello world\".split(), \"tokenize text datas with batch\".split(), \"this is a test\".split()]\n",
    "indices = tokenizer.encode(raw_text, padding_first=True)\n",
    "decode_text = tokenizer.decode(indices.tolist(), remove_bos=False, remove_eos=False, remove_pad=False)\n",
    "print(\"raw text\")\n",
    "for raw in raw_text:\n",
    "    print(raw)\n",
    "print(\"indices\")\n",
    "for index in indices:\n",
    "    print(index)\n",
    "print(\"decode text\")\n",
    "for decode in decode_text:\n",
    "    print(decode)"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:48.569154Z",
     "iopub.execute_input": "2023-12-08T03:56:48.569535Z",
     "iopub.status.idle": "2023-12-08T03:56:48.597133Z",
     "shell.execute_reply.started": "2023-12-08T03:56:48.569501Z",
     "shell.execute_reply": "2023-12-08T03:56:48.596078Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2025-02-04T06:55:46.751022Z",
     "start_time": "2025-02-04T06:55:46.719795Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "raw text\n",
      "['hello', 'world']\n",
      "['tokenize', 'text', 'datas', 'with', 'batch']\n",
      "['this', 'is', 'a', 'test']\n",
      "indices\n",
      "tensor([   0,    0,    0,    1, 4825,  182,    3])\n",
      "tensor([    1,     2,  3004,     2,    19, 19233,     3])\n",
      "tensor([   0,    1,   14,    9,    6, 2181,    3])\n",
      "decode text\n",
      "[PAD] [PAD] [PAD] [BOS] hello world [EOS]\n",
      "[BOS] [UNK] text [UNK] with batch [EOS]\n",
      "[PAD] [BOS] this is a test [EOS]\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "cell_type": "code",
   "source": [
    "# 看看训练集的数据\n",
    "\n",
    "tokenizer.decode(train_data[:2], remove_bos=False, remove_eos=False, remove_pad=False)"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:48.598454Z",
     "iopub.execute_input": "2023-12-08T03:56:48.598800Z",
     "iopub.status.idle": "2023-12-08T03:56:48.607972Z",
     "shell.execute_reply.started": "2023-12-08T03:56:48.598760Z",
     "shell.execute_reply": "2023-12-08T03:56:48.607067Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2025-02-04T06:55:46.757622Z",
     "start_time": "2025-02-04T06:55:46.752017Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"[BOS] this film was just brilliant casting location scenery story direction everyone's really suited the part they played and you could just imagine being there robert [UNK] is an amazing actor and now the same being director [UNK] father came from the same scottish island as myself so i loved the fact there was a real connection with this film the witty remarks throughout the film were great it was just brilliant so much that i bought the film as soon as it was released for [UNK] and would recommend it to everyone to watch and the fly fishing was amazing really cried at the end it was so sad and you know what they say if you cry at a film it must have been good and this definitely was also [UNK] to the two little boy's that played the [UNK] of norman and paul they were just brilliant children are often left out of the [UNK] list i think because the stars that play them all grown up are such a big profile for the whole film but these children are amazing and should be praised for what they have done don't you think the whole story was so lovely because it was true and was someone's life after all that was shared with us all\",\n",
       " \"[BOS] big hair big boobs bad music and a giant safety pin these are the words to best describe this terrible movie i love cheesy horror movies and i've seen hundreds but this had got to be on of the worst ever made the plot is paper thin and ridiculous the acting is an abomination the script is completely laughable the best is the end showdown with the cop and how he worked out who the killer is it's just so damn terribly written the clothes are sickening and funny in equal [UNK] the hair is big lots of boobs [UNK] men wear those cut [UNK] shirts that show off their [UNK] sickening that men actually wore them and the music is just [UNK] trash that plays over and over again in almost every scene there is trashy music boobs and [UNK] taking away bodies and the gym still doesn't close for [UNK] all joking aside this is a truly bad film whose only charm is to look back on the disaster that was the 80's and have a good old laugh at how bad everything was back then\"]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 8
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 数据集与 DataLoader"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "class IMDBDataset(Dataset):\n",
    "    def __init__(self, data, labels, remain_length=True):\n",
    "        if remain_length:\n",
    "            self.data = tokenizer.decode(data, remove_bos=False, remove_eos=False, remove_pad=False)\n",
    "        else:\n",
    "            # 缩减一下数据\n",
    "            self.data = tokenizer.decode(data)\n",
    "        self.labels = labels\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        text = self.data[index]\n",
    "        label = self.labels[index]\n",
    "        return text, label\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "    \n",
    "    \n",
    "def collate_fct(batch):\n",
    "    text_list = [item[0].split() for item in batch]\n",
    "    label_list = [item[1] for item in batch]\n",
    "    # 这里使用 padding first\n",
    "    text_list = tokenizer.encode(text_list, padding_first=True).to(dtype=torch.int)\n",
    "    return text_list, torch.tensor(label_list).reshape(-1, 1).to(dtype=torch.float)\n",
    "\n",
    "\n",
    "# 用RNN，缩短序列长度\n",
    "train_ds = IMDBDataset(train_data, train_labels, remain_length=False)\n",
    "test_ds = IMDBDataset(test_data, test_labels, remain_length=False)"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:48.609141Z",
     "iopub.execute_input": "2023-12-08T03:56:48.609455Z",
     "iopub.status.idle": "2023-12-08T03:56:54.659024Z",
     "shell.execute_reply.started": "2023-12-08T03:56:48.609429Z",
     "shell.execute_reply": "2023-12-08T03:56:54.658211Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2025-02-04T06:55:48.842725Z",
     "start_time": "2025-02-04T06:55:46.758781Z"
    }
   },
   "outputs": [],
   "execution_count": 9
  },
  {
   "cell_type": "code",
   "source": [
    "batch_size = 128\n",
    "train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True, collate_fn=collate_fct)\n",
    "test_dl = DataLoader(test_ds, batch_size=batch_size, shuffle=False, collate_fn=collate_fct)"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:54.660271Z",
     "iopub.execute_input": "2023-12-08T03:56:54.660748Z",
     "iopub.status.idle": "2023-12-08T03:56:54.675542Z",
     "shell.execute_reply.started": "2023-12-08T03:56:54.660707Z",
     "shell.execute_reply": "2023-12-08T03:56:54.674566Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2025-02-04T06:55:48.847441Z",
     "start_time": "2025-02-04T06:55:48.843712Z"
    }
   },
   "outputs": [],
   "execution_count": 10
  },
  {
   "cell_type": "code",
   "source": [
    "for text, label in train_dl:\n",
    "    print(text.shape, label.shape)\n",
    "    break"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-04T06:55:48.892407Z",
     "start_time": "2025-02-04T06:55:48.848439Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([128, 500]) torch.Size([128, 1])\n"
     ]
    }
   ],
   "execution_count": 11
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 定义模型"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "class RNN(nn.Module):\n",
    "    def __init__(self, embedding_dim=16, hidden_dim=64, vocab_size=vocab_size, num_layers=1, bidirectional=False):\n",
    "        super(RNN, self).__init__()\n",
    "        self.embeding = nn.Embedding(vocab_size, embedding_dim)\n",
    "        self.rnn = nn.RNN(embedding_dim, hidden_dim, num_layers=num_layers, batch_first=True, bidirectional=bidirectional)\n",
    "        self.layer = nn.Linear(hidden_dim * (2 if bidirectional else 1), hidden_dim)  # bidirectional双向输出，默认False\n",
    "        self.fc = nn.Linear(hidden_dim, 1)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # [bs, seq length]->[bs, seq length, embedding_dim]\n",
    "        x = self.embeding(x)\n",
    "        # print(f'x.size()={x.size()}')\n",
    "        # [bs, seq length, embedding_dim] -> [bs,  seq length, hidden_dim],[ 1, bs,  hidden_dim]\n",
    "        seq_output, final_hidden = self.rnn(x)\n",
    "        # print(f'seq_output.size()={seq_output.size()}')\n",
    "        # print(f'final_hidden.size()={final_hidden.size()}')\n",
    "        # [ bs,  hidden_dim]\n",
    "        x = seq_output[:, -1, :]  # 取最后一个时间步的输出（原先有seq length个输出），这里的x=final_hidden\n",
    "        # print(f'x.size()={x.size()}')\n",
    "        # 取最后一个时间步的输出 (这也是为什么要设置padding_first=True的原因)\n",
    "        x = self.layer(x)\n",
    "        x = self.fc(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "print(\"{:=^80}\".format(\" 一层单向 RNN \"))       \n",
    "for key, value in RNN().named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")  # ih是input*hidden=16*64，hh是W=64*64"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:54.680954Z",
     "iopub.execute_input": "2023-12-08T03:56:54.681375Z",
     "iopub.status.idle": "2023-12-08T03:56:54.704703Z",
     "shell.execute_reply.started": "2023-12-08T03:56:54.681337Z",
     "shell.execute_reply": "2023-12-08T03:56:54.703621Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2025-02-04T08:06:40.565693Z",
     "start_time": "2025-02-04T08:06:40.558584Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=================================== 一层单向 RNN ===================================\n",
      "            embeding.weight             paramerters num: 160000\n",
      "            rnn.weight_ih_l0            paramerters num: 1024\n",
      "            rnn.weight_hh_l0            paramerters num: 4096\n",
      "             rnn.bias_ih_l0             paramerters num: 64\n",
      "             rnn.bias_hh_l0             paramerters num: 64\n",
      "              layer.weight              paramerters num: 4096\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n"
     ]
    }
   ],
   "execution_count": 35
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-04T08:05:35.275854Z",
     "start_time": "2025-02-04T08:05:35.239753Z"
    }
   },
   "cell_type": "code",
   "source": [
    " # 前向计算，看输出的shape\n",
    "model = RNN()\n",
    "# 形状为(1, 500),大小为0-10000\n",
    "sample_inputs = torch.randint(0, vocab_size, (2, 500))  # vocab_size是词表大小，这里是10000\n",
    "model(sample_inputs).shape"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x.size()=torch.Size([2, 500, 16])\n",
      "seq_output.size()=torch.Size([2, 500, 64])\n",
      "final_hidden.size()=torch.Size([1, 2, 64])\n",
      "x.size()=torch.Size([2, 64])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "torch.Size([2, 1])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 34
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-04T06:56:20.148334Z",
     "start_time": "2025-02-04T06:56:20.140310Z"
    }
   },
   "cell_type": "code",
   "source": [
    "print(\"{:=^80}\".format(\" 一层双向 RNN \"))       \n",
    "for key, value in RNN(bidirectional=True).named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")\n",
    "\n",
    "    \n",
    "print(\"{:=^80}\".format(\" 俩层单向 RNN \"))       \n",
    "for key, value in RNN(num_layers=2).named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=================================== 一层双向 RNN ===================================\n",
      "            embeding.weight             paramerters num: 160000\n",
      "            rnn.weight_ih_l0            paramerters num: 1024\n",
      "            rnn.weight_hh_l0            paramerters num: 4096\n",
      "             rnn.bias_ih_l0             paramerters num: 64\n",
      "             rnn.bias_hh_l0             paramerters num: 64\n",
      "        rnn.weight_ih_l0_reverse        paramerters num: 1024\n",
      "        rnn.weight_hh_l0_reverse        paramerters num: 4096\n",
      "         rnn.bias_ih_l0_reverse         paramerters num: 64\n",
      "         rnn.bias_hh_l0_reverse         paramerters num: 64\n",
      "              layer.weight              paramerters num: 8192\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n",
      "=================================== 俩层单向 RNN ===================================\n",
      "            embeding.weight             paramerters num: 160000\n",
      "            rnn.weight_ih_l0            paramerters num: 1024\n",
      "            rnn.weight_hh_l0            paramerters num: 4096\n",
      "             rnn.bias_ih_l0             paramerters num: 64\n",
      "             rnn.bias_hh_l0             paramerters num: 64\n",
      "            rnn.weight_ih_l1            paramerters num: 4096\n",
      "            rnn.weight_hh_l1            paramerters num: 4096\n",
      "             rnn.bias_ih_l1             paramerters num: 64\n",
      "             rnn.bias_hh_l1             paramerters num: 64\n",
      "              layer.weight              paramerters num: 4096\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n"
     ]
    }
   ],
   "execution_count": 13
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 训练"
   ],
   "metadata": {}
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### evalueting"
  },
  {
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)         # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        # 二分类\n",
    "        preds = logits > 0\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "        \n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:54.705794Z",
     "iopub.execute_input": "2023-12-08T03:56:54.706059Z",
     "iopub.status.idle": "2023-12-08T03:56:54.713704Z",
     "shell.execute_reply.started": "2023-12-08T03:56:54.706035Z",
     "shell.execute_reply": "2023-12-08T03:56:54.712738Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2025-02-04T08:08:24.134876Z",
     "start_time": "2025-02-04T08:08:23.744003Z"
    }
   },
   "outputs": [],
   "execution_count": 36
  },
  {
   "cell_type": "markdown",
   "source": [
    "### TensorBoard 可视化\n",
    "\n",
    "\n",
    "训练过程中可以使用如下命令启动tensorboard服务。\n",
    "\n",
    "```shell\n",
    "tensorboard \\\n",
    "    --logdir=runs \\     # log 存放路径\n",
    "    --host 0.0.0.0 \\    # ip\n",
    "    --port 8848         # 端口\n",
    "```"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "        \n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\", \n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "            )\n",
    "        \n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "        \n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "            \n",
    "        )\n",
    "    \n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:54.714985Z",
     "iopub.execute_input": "2023-12-08T03:56:54.715274Z",
     "iopub.status.idle": "2023-12-08T03:56:54.727971Z",
     "shell.execute_reply.started": "2023-12-08T03:56:54.715249Z",
     "shell.execute_reply": "2023-12-08T03:56:54.726997Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2025-02-04T08:08:31.193112Z",
     "start_time": "2025-02-04T08:08:31.037078Z"
    }
   },
   "outputs": [],
   "execution_count": 37
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Save Best\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:54.731416Z",
     "iopub.execute_input": "2023-12-08T03:56:54.731736Z",
     "iopub.status.idle": "2023-12-08T03:56:54.741180Z",
     "shell.execute_reply.started": "2023-12-08T03:56:54.731693Z",
     "shell.execute_reply": "2023-12-08T03:56:54.740443Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2025-02-04T08:08:35.931506Z",
     "start_time": "2025-02-04T08:08:35.927505Z"
    }
   },
   "outputs": [],
   "execution_count": 38
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Early Stop"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1\n",
    "            \n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:54.742415Z",
     "iopub.execute_input": "2023-12-08T03:56:54.742724Z",
     "iopub.status.idle": "2023-12-08T03:56:54.753175Z",
     "shell.execute_reply.started": "2023-12-08T03:56:54.742698Z",
     "shell.execute_reply": "2023-12-08T03:56:54.752241Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2025-02-04T08:08:39.658335Z",
     "start_time": "2025-02-04T08:08:39.653586Z"
    }
   },
   "outputs": [],
   "execution_count": 39
  },
  {
   "cell_type": "code",
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits > 0\n",
    "            \n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())    \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                \n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                            )\n",
    "                \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "        \n",
    "    return record_dict\n",
    "        \n",
    "\n",
    "epoch = 20\n",
    "\n",
    "model = RNN()\n",
    "# model = RNN(bidirectional=True)\n",
    "# model = RNN(num_layers=2)\n",
    "# model = RNN(bidirectional=True,num_layers=2)\n",
    "# 1. 定义损失函数 采用交叉熵损失 (但是二分类)\n",
    "loss_fct = F.binary_cross_entropy_with_logits\n",
    "# 2. 定义优化器 采用 adam\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "if not os.path.exists(\"runs\"):\n",
    "    os.mkdir(\"runs\")\n",
    "tensorboard_callback = TensorBoardCallback(\"runs/imdb-rnn\")\n",
    "# tensorboard_callback.draw_model(model, [1, MAX_LENGTH])\n",
    "# 2. save best\n",
    "if not os.path.exists(\"checkpoints\"):\n",
    "    os.makedirs(\"checkpoints\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/imdb-rnn\", save_step=len(train_dl), save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10)\n",
    "\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model, \n",
    "    train_dl, \n",
    "    test_dl, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=tensorboard_callback,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_dl)\n",
    "    )"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:54.754553Z",
     "iopub.execute_input": "2023-12-08T03:56:54.754886Z",
     "iopub.status.idle": "2023-12-08T04:02:37.889132Z",
     "shell.execute_reply.started": "2023-12-08T03:56:54.754861Z",
     "shell.execute_reply": "2023-12-08T04:02:37.888109Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2025-02-04T08:19:43.663221Z",
     "start_time": "2025-02-04T08:09:55.718451Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/3920 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "a822bf1564714bdfaaa24b595f4833b6"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 41
  },
  {
   "cell_type": "code",
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        # axs[idx].set_xticks(range(0, train_df.index[-1], 5000))\n",
    "        # axs[idx].set_xticklabels(map(lambda x: f\"{int(x/1000)}k\", range(0, train_df.index[-1], 5000)))\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=10)  #横坐标是 steps"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T04:02:37.890371Z",
     "iopub.execute_input": "2023-12-08T04:02:37.890648Z",
     "iopub.status.idle": "2023-12-08T04:02:38.263775Z",
     "shell.execute_reply.started": "2023-12-08T04:02:37.890625Z",
     "shell.execute_reply": "2023-12-08T04:02:38.262830Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2025-02-04T08:22:45.558576Z",
     "start_time": "2025-02-04T08:22:45.403953Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 42
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 评估"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/imdb-rnn/best.ckpt\",weights_only=True, map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, test_dl, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T04:02:38.265426Z",
     "iopub.execute_input": "2023-12-08T04:02:38.265820Z",
     "iopub.status.idle": "2023-12-08T04:02:45.859021Z",
     "shell.execute_reply.started": "2023-12-08T04:02:38.265777Z",
     "shell.execute_reply": "2023-12-08T04:02:45.858108Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2025-02-04T08:23:08.492994Z",
     "start_time": "2025-02-04T08:23:01.503814Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.5569\n",
      "accuracy: 0.7346\n"
     ]
    }
   ],
   "execution_count": 44
  }
 ]
}
